/*
* sop组件表模块
*/
const express = require('express');
const router = express.Router();
// 引入数据库
const db = require("../../config/db");
// 引入时间包
const moment = require("moment");
// 引入方法库
const { toCamelCase, toUnderlineCase, verifyToken, recursionGenerateTree } = require("../../config/utils");
// 引入日志
const log = require("../log");

// 查询*sop*组件列表 模糊查询
router.post('/selectComponent', (req, res) => {
    console.log("===========查询*sop*组件列表 模糊查询============");
    const { name } = req.body;
    const sql = `select * from sop_components where name like'%${name}%'`;
    db.query("查询*sop*组件列表 模糊查询", sql, (err, result) => {
        if (err) {
            res.send({ code: 500, msg: '查询*sop*组件列表 模糊查询失败' })
            return
        }
        // 变量Json数组key转成下划线第一个大写
        result = result.map(item => {
            return toCamelCase(item)
        })
        res.send({
            code: 200,
            msg: '查询*sop*组件列表 模糊查询成功',
            data: result,
        })
    })
})

// 新增*sop组件*
router.post("/addComponent", (req, res) => {
    console.log("=========== 新增*sop组件*接口============");
    // 获取参数
    let { deptName, parentId, status, orderNum, leader, phone, email, tableData } = req.body;
    // 截取id字段
    parentId = parentId.split("-")[1];
    // 获取创建人
    let { username } = verifyToken(req.headers.authorization);
    // 获取创建时间
    let createTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 判断当前组件名称是否存在
    let sql_check = `select * from sop_components where name = '${deptName}'`;
    db.query("判断当前组件名称是否存在", sql_check, (err, sql_check_result) => {
        if (err) {
            res.send({ code: 500, msg: "判断当前组件名称是否存在失败", data: err });
            return;
        }
        if (sql_check_result.length > 0) {
            res.send({ code: 500, msg: "已存在相同组件名称，请重新输入！" });
            return;

        }
        // 插入数据库
        let sql = `insert into sop_components (name, status, create_by, create_time, leader, phone, email, table_data) values 
        ('${deptName}', '${status}', '${username}', '${createTime}', ${leader ? "'" + leader + "'" : null}, 
        ${phone ? "'" + phone + "'" : null}, ${email ? "'" + email + "'" : null}, ${tableData ? "'" + tableData + "'" : null})`;
        db.query("新增*sop组件*", sql, (err1, result) => {
            if (err1) {
                res.send({ code: 500, msg: "新增*sop组件*失败", data: err1 });
                return;
            }
            if (result.affectedRows > 0) {
                // 在关联表中插入设备id和组件id
                let sql2 = `insert into sop_device_sop_components (device_id, component_id, order_num) values 
                ('${parentId}', '${result.insertId}', '${orderNum}')`;
                db.query("新增*sop组件*关联*设备与组件*表", sql2, (err2, result2) => {
                    if (err2) {
                        res.send({ code: 500, msg: "新增*sop组件*关联*设备与组件*表失败", data: err2 });
                        return;
                    }
                    if (result2.affectedRows > 0) {
                        res.send({ code: 200, msg: "新增*sop组件*成功" });
                    } else {
                        res.send({ code: 500, msg: "新增*sop组件*关联*设备与组件*表失败" });
                    }
                })

            } else {
                res.send({ code: 500, msg: "新增*sop组件*失败" });
            }
        })
    })
})

// 修改*sop组件*
router.put("/updateComponent", (req, res) => {
    console.log("=========== 修改*sop组件*接口============");
    // 获取参数
    let { deptName, parentId, status, deptId, leader, phone, email, tableData } = req.body;
    // 截取id字段
    deptId = deptId.split("-")[1];
    // 获取创建人
    let { username } = verifyToken(req.headers.authorization);
    // 获取创建时间
    let createTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 组件名称修改, 需要判断是否复用
    // 判断设备组件关联表是否存在两个以上数据  LIMIT 1 OFFSET 1;  -- 存在第二条时返回1，否则无结果
    let sql_check = `select * from sop_device_sop_components where component_id = '${deptId}' LIMIT 1 OFFSET 1`;
    db.query("判断设备组件关联表是否存在两个以上数据", sql_check, (err, sql_check_result) => {
        if (err) {
            res.send({ code: 500, msg: "判断设备组件关联表是否存在两个以上数据失败", data: err });
            return;
        }
        if (sql_check_result.length > 0) {
            res.send({ code: 500, msg: "当前组件绑定多个设备，无法修改组件名称！" });
        } else {
            // 判断当前组件名称是重复
            let sql_check = `select * from sop_components where name = '${deptName}' and id != '${deptId}'`;
            db.query("修改*sop组件*判断当前组件名称是重复", sql_check, (err, sql_check_result) => {
                if (err) {
                    res.send({ code: 500, msg: "修改*sop组件*判断当前组件名称是重复失败", data: err });
                    return;
                }
                if (sql_check_result.length > 0) {
                    res.send({ code: 500, msg: "已存在相同组件名称，请重新输入！" });
                    return;
                }
                // 修改组件名称, 排序，图片，安装后效果，备件信息
                let sql = `update sop_components set name = '${deptName}', leader = ${leader ? "'" + leader + "'" : null}, phone = ${phone ? "'" + phone + "'" : null}, 
                email = ${email ? "'" + email + "'" : null}, table_data = ${tableData ? "'" + tableData + "'" : null},
                update_by = '${username}', update_time = '${createTime}'
                where id = '${deptId}'`;
                db.query("修改*sop组件*名称, 排序，图片，安装后效果，备件信息", sql, (err1, result) => {
                    if (err1) {
                        res.send({ code: 500, msg: "修改*sop组件*名称, 排序，图片，安装后效果，备件信息失败", data: err1 });
                        return;
                    }
                    if (result.affectedRows > 0) {
                        res.send({ code: 200, msg: "修改*sop组件*名称, 排序，图片，安装后效果，备件信息成功" });
                    } else {
                        res.send({ code: 500, msg: "修改*sop组件*名称, 排序，图片，安装后效果，备件信息失败" });
                    }
                })
            })
        }
    })
    // // 判断组件名称是否修改
    // let sql_check_name = `select name from sop_components where id = '${deptId}'`
    // db.query("判断组件名称是否修改", sql_check_name, (err, sql_check_name_result) => {
    //     if (err) {
    //         res.send({ code: 500, msg: "判断组件名称是否修改失败", data: err });
    //         return;
    //     }
    //     if (sql_check_name_result[0].name == deptName){
    //         res.send({ code: 200, msg: "组件名称未修改，无需修改！" });
    //     }else{

    //     }
    // })
})

// 新增*sop组件复用工序信息* 
// 1:查询新组件名称是否重复 2:查询旧组件信息给到新组件 3:返回新组件id替换设备组件关联表中的旧组件id 4:查询旧组件工序关联表的数据 5:根据数据批量插入新组件工序关联表
router.post("/addComponentReuseProcess", (req, res) => {
    console.log("=========== 新增*sop组件复用工序信息*接口============");
    // 获取参数
    let { deviceId, name, componentId, processId } = req.body;
    // 获取创建人
    let { username } = verifyToken(req.headers.authorization);
    // 获取创建时间
    let createTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 查询新组件名称是否重复
    let sql_check = `select * from sop_components where name = '${name}'`;
    db.query("新增*sop组件复用工序信息*查询新组件名称是否重复", sql_check, (err, sql_check_result) => {
        if (err) {
            res.send({ code: 500, msg: "新增*sop组件复用工序信息*查询新组件名称是否重复失败", data: err });
            return;
        }
        if (sql_check_result.length > 0) {
            res.send({ code: 500, msg: "已存在相同组件名称，请重新输入！" });
            return;
        } else {
            // 新组件名称不重复，查询旧组件信息给到新组件
            let sql_select_id = `select * from sop_components where id = '${componentId}'`;
            db.query("新增*sop组件复用工序信息*查询旧组件信息给到新组件", sql_select_id, (err1, result) => {
                if (err1) {
                    res.send({ code: 500, msg: "新增*sop组件复用工序信息*查询旧组件信息给到新组件失败", data: err1 });
                    return;
                }
                if (result.length > 0) {
                    // 新增新组件,把旧组件信息给到新组件
                    let { status, leader, phone, email, table_data } = result[0];
                    let sql_insert = `insert into sop_components (name, status, create_by, create_time, leader, phone, email, table_data) 
                    values ('${name}', '${status}', '${username}', '${createTime}', ${leader ? "'" + leader + "'" : null}, ${phone ? "'" + phone + "'" : null}, ${email ? "'" + email + "'" : null}, ${table_data ? "'" + table_data + "'" : null})`
                    db.query("新增*sop组件复用工序信息*新增新组件", sql_insert, (err2, result2) => {
                        if (err2) {
                            res.send({ code: 500, msg: "新增*sop组件复用工序信息*新增新组件失败", data: err2 });
                            return;
                        }
                        if (result2.affectedRows > 0) {
                            // 返回新组件id
                            let newComponentId = result2.insertId;
                            // 修改改设备组件关联表中的旧组件id为新的组件id
                            let sql_update = `update sop_device_sop_components set component_id = '${newComponentId}' where device_id = '${deviceId}' and component_id = '${componentId}'`;
                            db.query("新增*sop组件复用工序信息*修改改设备组件关联表中的旧组件id为新的组件id", sql_update, (err3, result3) => {
                                if (err3) {
                                    res.send({ code: 500, msg: "新增*sop组件复用工序信息*修改改设备组件关联表中的旧组件id为新的组件id失败", data: err3 });
                                    return;
                                }
                                if (result3.affectedRows > 0) {
                                    // 查询旧组件工序关联表的所有数据
                                    let sql_select_process = `select * from sop_components_sop_process where component_id = '${componentId}' and process_id != '${processId}'`;
                                    db.query("新增*sop组件复用工序信息*查询旧组件工序关联表的所有数据", sql_select_process, (err4, result4) => {
                                        if (err4) {
                                            res.send({ code: 500, msg: "新增*sop组件复用工序信息*查询旧组件工序关联表的所有数据失败", data: err4 });
                                            return;
                                        }
                                        if (result4.length > 0) {
                                            // 整理数据到sql语句中
                                            let data = result4.map(item => {
                                                return `(${newComponentId}, ${item.process_id}, ${item.order_num})`
                                            })
                                            // 批量插入新组件工序关联表
                                            let sql_insert_process = `insert into sop_components_sop_process (component_id, process_id, order_num) values ${data.join(",")} `;
                                            db.query("新增*sop组件复用工序信息*批量插入新组件工序关联表", sql_insert_process, (err5, result5) => {
                                                if (err5) {
                                                    res.send({ code: 500, msg: "新增*sop组件复用工序信息*批量插入新组件工序关联表失败", data: err5 });
                                                    return;
                                                }
                                                if (result5.affectedRows > 0) {
                                                    res.send({ code: 200, msg: "新增*sop组件复用工序信息*成功" });
                                                } else {
                                                    res.send({ code: 500, msg: "新增*sop组件复用工序信息*批量插入新组件工序关联表失败" });
                                                    return;
                                                }
                                            })
                                        } else {
                                            res.send({ code: 500, msg: "新增*sop组件复用工序信息*查询旧组件工序关联表的所有数据失败" });
                                            return;
                                        }
                                    })
                                }
                            })
                        } else {
                            res.send({ code: 500, msg: "新增*sop组件复用工序信息*新增新组件失败" });
                            return;
                        }
                    })
                } else {
                    res.send({ code: 500, msg: "新增*sop组件复用工序信息*查询旧组件信息给到新组件失败" });
                    return;
                }
            })

        }
    })
})


module.exports = router;